package struct.stack;

import cn.hutool.core.io.LineHandler;
import cn.hutool.core.io.file.FileReader;
import cn.hutool.core.util.StrUtil;
import com.sun.xml.internal.bind.v2.model.core.ElementInfo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Objects;

/**
 * @description:
 * 一段合法的Java代码，不含任何注释。循环语句只有for，条件语句只有if，循环语句和条件语句保证包含大括号用来控制范围。
 * 代码中只有一个类和一个主函数。
 * 需求：判断其中最多有多少层for循环嵌套。
 * 如下代码，经过判断后输出：2，标识最多只有两层for循环嵌套。
 * public class Main{
 *     public static void main(String[] args){
 *         Scanner in = new Scanner(System.in);
 *         int a = 0 , b = 0;
 *         int n = in.nextInt();
 *         for (int i = 0; i < n; i++) {
 *             if ( a < b ) {
 *                 a += b / 2;
 *             }
 *             for (int j = 0; j < n; j++) {
 *                 b++;
 *                 a += b;
 *             }
 *             for (int j = 1; j < n; j *= 2) {
 *                 b--;
 *             }
 *         }
 *         System.out.println(a);
 *     }
 * }
 * @author: kanggw
 * @date: 2024/6/25
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Accessors(chain = true)
public class NestCheck {

    /**
     * 思路：首先采用栈这种数据结构来处理这个问题比较简单
     * 遇到for则入栈，入栈前先判断栈顶的元素是不是for,如果是则取这个for的层次数与记录的最大层数进行比较，如果相等则最大层数+1，如果小于最大层数则，最大层数不变，当前要入栈的for层数记录为栈顶元素层数+1.遇到}则出栈。直到遇到空串结束检查
     */
    private Deque<ElementInfo> deque = new ArrayDeque<>();
    private Integer level = 0;


    public  void check(){

        FileReader fileReader = new FileReader("/Users/guoweikang/Downloads/testForNest.java");
        fileReader.readLines((LineHandler) line -> {
            if (line.contains("for") ) {
                if ("for".equals(deque.peek()
                                      .getElement())) {
                    ElementInfo peek = deque.peek();
                    if (peek.getLevel() == this.level) {
                        this.level++;
                        deque.push(ElementInfo.builder()
                                              .element("for")
                                              .level(this.level)
                                              .build());
                    } else {
                        deque.push(ElementInfo.builder()
                                              .element("for")
                                              .level(peek.getLevel() + 1)
                                              .build());
                    }
                } else {

                    deque.push(ElementInfo.builder()
                                          .element("for")
                                          .level(1)
                                          .build());
                    if (this.level == 0) {
                        this.level =1;
                    }
                }
                return;
            }
            if (line.contains("{")) {
                deque.push(ElementInfo.builder().element("{").build());
            }
            if (line.contains("}")) {
                deque.pop();
            }
            });

        System.out.println("for循环嵌套次数"+ this.level);
    }

    public static void main(String[] args) {
        NestCheck nestCheck = new NestCheck();
        nestCheck.check();
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    @Accessors(chain = true)
    public static class ElementInfo{

        private String element;
        private Integer level;
    }

}
